import os
'''
数据类型
int（） - 将任何数据类型转换为整数类型
float（） - 将任何数据类型转换为float类型
ord（） - 将字符转换为整数
hex（） - 将整数转换为十六进制
oct（） - 将整数转换为八进制
tuple（） -此函数用于转换为元组。
set（） -此函数在转换为set后返回类型。
list（） -此函数用于将任何数据类型转换为列表类型。
dict（） -此函数用于将顺序元组（键，值）转换为字典。
str（） -用于将整数转换为字符串。
complex（real，imag） - 此函数将实数转换为复数（实数，图像）数。

 
'''
print(os.getcwd())
############################################################################################
print('第9部分')
'''
字符串
'''
# 1、字符串定义
str1 = '他的名字是Timi'
str2 = "他的名字是Timi"
str3 = '''他的名字是Timi'''
str4 = """他的名字是Timi"""

# 2、单引号双引号用法    字符串内部与外部不能都用单引号或者双引号
str1 = '他的名字是"Timi"'
str1 = "他的名字是'Timi'"

# 3、字符串拼接
str1 = '他的名字'
str2 = '是"Timi"'
str3 = str1 + str2
print(str3)

# 4、字符串的长度
str1 = '他的名字'
str2 = '是"Timi"'
str3 = str1 + str2
print(len(str1))
print(len(str3))

# 5、字符串的转义
r'''
\n 
\t 
\b 
\r 
'''
print('我是一个\n字符串')  # \n  换行
print('我是一个\t字符串')  # \t  TAB空格缩进一般填充到4个空格
print('我是一个\b 字符串')  # \b退格去掉'个'
print('我是一个\r字符串')  # \r换行，但去掉前面的重新输入

# 6、字符串的sep
print('我是一个', '字符串', 'string', sep=':')  # 我是一个:字符串:string

# 7、字符串重复输出
print('我是一个字符串'*5)

# 8、字符串输出不换行
for i in range(10):
    print(i)
for i in range(10):
    print(i, end=' ')

# 9、字符串下标与切片[起始偏移量：结束偏移量：步长]
str1 = '他的名字是Tomi'  # 下标范围是 零0 到 len(str1)-1【字符串长度-1】
print(str1[0], str1[3], str1[-1], str1[-2])  # 输出特定下标字符
print(str1[0:3])  # 输出下标范围
print(str1[::2])  # 步长为2
print(str1[::-1])  # 倒着输出

# 10、字符串替换
str1 = '他的名字是Tomi'
print(str1.replace('Tomi', 'Sandy'))

# 11、字符串切割与拼接
str1 = r'/code_test/pythonProject1'
str2 = str1.split('/')  # 分割
print(str2)
str3 = '/'.join(str2)  # 拼接
print(str3)

# 12、字符串的驻留机制（id）
str4 = r'/code_test/pythonProject1'
print(id(str1), id(str2), id(str3), id(str4))  # 2186772353216 2186772329984 2186772353536 2186772353216
# 字符串是不可变的数据类型，每次都是[生成]新的字符串，内容相同[id]也会[不同]。直接赋值才会相同
# 常量字符串只会保留一个，新生成的字符串id也是不同的

# 13、字符串的比较
print(str1 == str4)  # True 比较的内容
print(str1 is str4)  # True 比较的内存地址

# 14、字符串的查询
str1 = '他的名字是Timi'
print(f'Timi 在 str1 里，结果为:{"Timi" in str1}')
print(str1.find('i'))  # 从左到右开始数，输出下标：6
print(str1.rfind('i'))  # 从右边开始数，得到结果输出下标：8
print(str1.index('Timi'),str1[5:9])  # 从左到右，查询'Timi'最开始的下标：5
print(str1.count('i'))  # 字符'i'的数量为 2

# 15、字符串的去除首尾
str1 = '***他的名字是Timi***'
print(str1.strip('*'))  # strip去掉左、右的*  不写*默认是空格
print(str1.lstrip('*'))  # lstrip去掉左  的*  不写*默认是空格
print(str1.rstrip('*'))  # rstrip去掉  右的*  不写*默认是空格

# 16、字符串的大小写转换
str1 = 'DANNY'
print('danny'.upper())  # 全大写
print('DANNY'.lower())  # 全小写
print('danny'.title())  # 开头大写
print('danny'.capitalize())  # 开头大写
print('danny'.swapcase())  # 全大写

# 17、字符串的排版
str1 = '他的名字是Timi'
print(str1.center(16, '='))  # 用等号=填充字符串的左右，字数不对齐右边多一个

############################################################################################
print('\n第10部分')
'''
列表
'''

# 1、列表创建
str1 = '他的名字是Timi'
list1 = list(str1)  # ['他', '的', '名', '字', '是', 'T', 'i', 'm', 'i']
list2 = list()  # 空列表[]
list3 = list(range(1,10))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]  从【1】到【10-1】的范围

# 列表[起始值:结束偏移量:步长]  列表下标从0开始，后面一个数据下标就加1
print(list3[1:5:2])  # list3[1:5]得到[2, 3, 4, 5]，步长为2，获得[2, 4]
# 列表长度
print(len(list3))  # 长度为10，下标【0，9】

# 2、列表的增
list1 = [1, 2, 3, 4, 5]
print(id(list1), type(list1), len(list1), list1)  # 2405940277760 <class 'list'> 5 [1, 2, 3, 4, 5]
list1.append(10)  # 添加后地址不变，长度增加
print(id(list1), type(list1), len(list1), list1)  # 2405940277760 <class 'list'> 6 [1, 2, 3, 4, 5, 10]
list2 = list1 + [20]  # 列表相加
print(id(list2), type(list2), len(list2), list2)  # 2405940265088 <class 'list'> 7 [1, 2, 3, 4, 5, 10, 20]
list2.extend([30,40])  # 列表扩展 地址不变，长度增加
print(id(list2), type(list2), len(list2), list2)  # 2405940265088 <class 'list'> 9 [1, 2, 3, 4, 5, 10, 20, 30, 40]
list2.insert(1, 99)  # 下标1的位置开始数据后移一位，在原来下标1的位置放上99
print(id(list2), type(list2), len(list2), list2)  # 2405940265088 <class 'list'> 10 [1, 99, 2, 3, 4, 5, 10, 20, 30, 40]

list3 = [1, 2, 3, 4, 5] * 2  # 用乘法增加
print(list3)  # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

# 3、列表的删
list1 = [1, 2, 3, 4, 5]
print(id(list1))  # 2767905358400
list1.pop()  # 删除最后一个（即5）
list1.pop(1)  # 删除最后一个下标1的数据（即2）
print(id(list1))  # 2767905358400 地址不变
list1.remove(3)  # 删除【3】这个数据（即3）
print(id(list1))  # 2767905358400 地址不变

# 4、列表的统计与访问  [起始值:结束偏移量:步长]  # 下标范围包括起始值，不包括下标结束值，从起始值的数据开始下标加上步长就是在访问的范围中
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
print(list1[1:5:2])  # list3[1:5]得到[2, 3, 4, 5]，步长为2，获得[2, 4]
print(list1.index(2))  # 2在list1中下标为1
print(list1.count(5), list1.count(2))  # 5有2个 2有1个
print(list1[-8:-2])  # [2, 3, 4, 5, 6, 7, 8]
# 5、列表的排序
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
print(list1[::-1])  # [5, 9, 8, 7, 6, 5, 4, 3, 2, 1]倒排
list1.sort()  # reverse默认False，不进行倒排
print(list1)  # [1, 2, 3, 4, 5, 5, 6, 7, 8, 9]  排序
list1.sort(reverse=True)  # 这次是进行倒排
print(list1)

a = [1, 12, 3, 74, 5, 36, 7, 8, 9, 5]
b = sorted(a)
print(b)  # [1, 3, 5, 5, 7, 8, 9, 12, 36, 74]
c = sorted(a, reverse=True)
print(c)  # [74, 36, 12, 9, 8, 7, 5, 5, 3, 1]

# 6、列表的内置函数
list1 = [1, 2, 3, 4, 5]
print(max(list1))  # 最大值
print(min(list1))  # 最小值
print(sum(list1))  # 总和

# 7、二维列表
list1 = [['Tom', 1], ['Jerry', 2]]  #
print(list1[0][1])  # [0]指list1第一个值['Tom', 1] 后面的[1]是['Tom', 1]的第二个值1
print(list1[1][0])  # [1]指list1第二个值['Jerry', 2] 后面的[1]是['Jerry', 2]的第一个值'Jerry'


############################################################################################
print('\n第11部分')
'''
元组
'''
tuple1 = (1, )  # 元组
tuple2 = (1)  # int数字
print(tuple1, type(tuple1), tuple2, type(tuple2))  # (1,) <class 'tuple'> 1 <class 'int'>

tuple1 = (1, 2, 3, 'Jerry', [10, 20, 30])
# 下标     0, 1, 2, 3       ,4
print(tuple1[1], tuple1[3], tuple1[4])  # 2 Jerry [10, 20, 30]
print(tuple1[:2:])  # (1, 2)
print(tuple1[3][2])  # 'r'
print(tuple1[4][2])  # 30

print(len(tuple1))  # 长度5
print(tuple1.count(2))  # 数据2的个数有一个
print(tuple1.count('e'))  # 数据'e'不存在

# tuple是不可变类型，只能生成新的
# tuple1[1] = 22  # tuple1报错

# 类型转换，列表变元组
list1 = [10, 20, 30]
tuple1 = tuple(list1)
print(tuple1, type(tuple1))  # (10, 20, 30) <class 'tuple'>

# zip方法

list1 = [1,2,3]
list2 = [4,5,6]
list3 = [10,20,30,40]
d = zip(list1, list2, list3)
print(d)  # <zip object at 0x000002302D378240>
print(list(d))  # [(1, 4, 10), (2, 5, 20), (3, 6, 30)]      每个列表下标对应的放一起

# 元组排序
a = (40, 30, 20, 10)
b = sorted(a)
print(b)  # [10, 20, 30, 40]变为列表

############################################################################################
print('\n第12部分')
'''
字典
由key键:value值对组成的
字典是无序可变的
key只能用[不可变]数据：字符串、元组、数字都是不可变类型，    key不可重复 整数 浮点数
value可以重复
'''

# 1、字典创建
dict1 = {'name': 'Tom', 'age': 7}
print(dict1, id(dict1), type(dict1))  # {'name': 'Tom', 'age': 7} 2405940153664 <class 'dict'>

key1 = ['name', 'age']
value1 = ['Tom', 7]
dict1 = dict(zip(key1, value1))  #
print(dict1, id(dict1), type(dict1))  # {'name': 'Tom', 'age': 7} 2405940342592 <class 'dict'>

dict1 = dict([['name', 'age'], ['Tom', 7]])  # 列表变字典
print(dict1, id(dict1), type(dict1))  # {'name': 'age', 'Tom': 7} 2405907491648 <class 'dict'>

# 2、字典访问
dict1 = {'name': 'Tom', 'age': 7, '属性': [1, 2, 3]}
print(dict1['name'])  # Tom
print(dict1['age'])  # 7
print(dict1['属性'])  # [1,2,3]None
print(dict1['属性'][1])  # [1,2,3]  # 2

print(dict1.get('age'))  # 7
print(dict1.get('na'))  # None

# 键值对访问
d = dict1.items()
print(d)  # dict_items([('name', 'Tom'), ('age', 7), ('属性', [1, 2, 3])])
print(dict1.keys())  # dict_keys(['name', 'age', '属性'])
print(dict1.values())  # dict_values(['Tom', 7, [1, 2, 3]])

print('name' not in dict1)  # False 检查dict1的所有key键中有没有name
print('Tom' not in dict1)  # True 检查dict1的所有key键中有没有name
print('Tom' in dict1)  # False 检查dict1的所有key键中有没有name

# 2、字典的添加
dict1 = {'name': 'Tom', 'age': 7}
print(dict1.get('属性'))  # None
dict1['属性'] = [1, 2, 3]  # 有属性会覆盖，没有则会创建
print(dict1['属性'])  # [1, 2, 3]
dict1['属性'] = [4, 5, 6]  # 有属性会覆盖，没有则会创建
print(dict1['属性'])  # [4,5,6]

# 3、字典的更新
dict1 = {'name': 'Tom', 'age': 7}
dict2 = {'name': 'TIMI', 'age': 14, '属性': [1, 2, 3]}
dict1.update(dict2)
print(dict1)  # {'name': 'TIMI', 'age': 14, '属性': [1, 2, 3]}  替换key一样的内容，不一样的添加进去

# 4、字典的删除
dict2 = {'name': 'TIMI', 'age': 14, '属性': [1, 2, 3]}
dict2.pop('name')  # 删除name
print(dict2)  # {'age': 14, '属性': [1, 2, 3]}  删除
print(dict2.popitem())  # {'age': 14, '属性': [1, 2, 3]}  随机删除
print(dict2)  # {'age': 14, '属性': [1, 2, 3]}  随机删除
print(dict2.popitem())  # 最后一个key：value删除了
print(dict2)  # 所有内容都删除了，返回一个{}空字典

# 序列解包  两边数量要一致

# 普通序列
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3
# 元组序列
(a, b, c) = (1, 2, 3)
print(a, b, c)  # 1 2 3
# 列表
[a, b, c] = [1, 2, 3]
print(a, b, c)  # 1 2 3

# 字典的items
dict2 = {'name': 'TIMI', 'age': 14, 'sex': 'man'}
name, age, sex = dict2
print(name, age, sex)  # name age sex
name, age, sex = dict2.items()
print(name, age, sex)  # ('name', 'TIMI') ('age', 14) ('sex', 'man')
name, age, sex = dict2.values()
print(name, age, sex)  # TIMI 14 man

############################################################################################
print('\n第13部分')
'''
集合
无序的，可变的，不允许重复
'''
# 1、集合的创建
set1 = set()
print(type(set1))  # <class 'set'>
set1 = {1, 2, 3, 4}
print(type(set1))  # <class 'set'>

# 最大用途：快速去重，之后排序
list1 = [1, 2, 3, 3, 3]
set1 = set(list1)
print(set1)  # {1, 2, 3}
list1 = list(set1)
list1.sort()
print(list1)  # [1, 2, 3, 4]

# 2、集合的添加
set1 = {1, 2, 3, 4}
set1.add(5)
print(set1)  # {1, 2, 3, 4, 5}

# 3、集合的删除
set1.remove(3)
print(set1)  # {1, 2, 4, 5}

# 清空
set1.clear()
print(set1)  # set()空集合

# 集合 交集、并集、差集
s = {1, 2, 3, 4}
s2 = {3, 30}
print(s - s2)  # 从s中删除s2的元素

print(s.intersection(s2))
print(s & s2)  # 交集 {3}
print(s.union(s2))  # 并集 {1, 2, 3, 4, 30}
print(s | s2)  # 并集 {1, 2, 3, 4, 30}
print(s.difference(s2))  # 从s中删除s2的元素
print(s ^ s2)  # 差集 {1, 2, 4, 30} s、s2不重复的值

